在 Java 中，`filter` 是一种常见的操作，通常用于从集合（如 `List`、`Set` 或 `Stream`）中筛选出符合条件的元素。以下是几种常见的 `filter` 实现方式：

---

### **1. 使用 `Stream` API（Java 8+）**
`Stream` API 提供了 `filter` 方法，可以轻松地筛选集合中的元素。

#### **示例：筛选出大于 5 的数字**
```java
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用 Stream 过滤出大于 5 的数字
        List<Integer> filteredNumbers = numbers.stream()
                .filter(n -> n > 5) // 过滤条件
                .collect(Collectors.toList()); // 收集结果

        System.out.println(filteredNumbers); // 输出: [6, 7, 8, 9, 10]
    }
}
```

---

### **2. 使用 `for` 循环**
如果不使用 `Stream`，可以通过 `for` 循环手动筛选元素。

#### **示例：筛选出偶数**
```java
import java.util.ArrayList;
import java.util.List;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> evenNumbers = new ArrayList<>();

        // 使用 for 循环筛选偶数
        for (Integer number : numbers) {
            if (number % 2 == 0) {
                evenNumbers.add(number);
            }
        }

        System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]
    }
}
```

---

### **3. 使用 `Predicate`**
`Predicate` 是 Java 8 引入的函数式接口，可以用于定义过滤条件。

#### **示例：筛选出长度大于 3 的字符串**
```java
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class FilterExample {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cat", "dog", "elephant");

        // 定义过滤条件
        Predicate<String> lengthGreaterThan3 = word -> word.length() > 3;

        // 使用 Stream 和 Predicate 过滤
        List<String> filteredWords = words.stream()
                .filter(lengthGreaterThan3)
                .collect(Collectors.toList());

        System.out.println(filteredWords); // 输出: [apple, banana, elephant]
    }
}
```

---

### **4. 使用 `removeIf`**
`removeIf` 是 `Collection` 接口的方法，可以移除不符合条件的元素。

#### **示例：移除小于 0 的数字**
```java
import java.util.ArrayList;
import java.util.List;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>(List.of(-2, -1, 0, 1, 2));

        // 移除小于 0 的数字
        numbers.removeIf(n -> n < 0);

        System.out.println(numbers); // 输出: [0, 1, 2]
    }
}
```

---

### **5. 自定义过滤方法**
如果需要更复杂的逻辑，可以编写自定义的过滤方法。

#### **示例：筛选出质数**
```java
import java.util.ArrayList;
import java.util.List;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<Integer> primes = filterPrimes(numbers);

        System.out.println(primes); // 输出: [2, 3, 5, 7]
    }

    // 自定义过滤方法：筛选质数
    private static List<Integer> filterPrimes(List<Integer> numbers) {
        List<Integer> primes = new ArrayList<>();
        for (Integer number : numbers) {
            if (isPrime(number)) {
                primes.add(number);
            }
        }
        return primes;
    }

    // 判断是否为质数
    private static boolean isPrime(int number) {
        if (number < 2) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(number); i++) {
            if (number % i == 0) {
                return false;
            }
        }
        return true;
    }
}
```

---

### **6. 使用第三方库（如 Guava）**
如果需要更强大的过滤功能，可以使用第三方库，如 Google 的 Guava。

#### **示例：使用 Guava 过滤**
```java
import com.google.common.base.Predicate;
import com.google.common.collect.Collections2;
import com.google.common.collect.Lists;

import java.util.List;

public class FilterExample {
    public static void main(String[] args) {
        List<Integer> numbers = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 使用 Guava 过滤出偶数
        Predicate<Integer> isEven = new Predicate<Integer>() {
            @Override
            public boolean apply(Integer number) {
                return number % 2 == 0;
            }
        };

        List<Integer> evenNumbers = Lists.newArrayList(Collections2.filter(numbers, isEven));

        System.out.println(evenNumbers); // 输出: [2, 4, 6, 8, 10]
    }
}
```

---

### **总结**
- **`Stream` API**：推荐使用，简洁高效。
- **`for` 循环**：适合简单场景。
- **`Predicate`**：灵活且可复用。
- **`removeIf`**：直接修改集合。
- **自定义方法**：适合复杂逻辑。
- **第三方库**：提供更多功能。

根据具体需求选择合适的方式！如果有其他问题，请随时提问。